package com.dk.service.impl;

import com.dk.mapper.SslMenuMapper;
import com.dk.pojo.SslMenu;
import com.dk.pojo.SslMenuExample;
import com.dk.service.SslMenuService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@DubboService
@Service
public class SslMenuServiceImpl implements SslMenuService {

    @Autowired
    private SslMenuMapper menuMapper;



    @Override
    public List<Map<String, Object>> getMenu(Integer pid) {
        // 获取菜单表中所有的数据
        //List<Menu> menuList = menuMapper.selectByExample(new MenuExample());
        //根据用户id查询用户所拥有的权限
        List<SslMenu> menuList = menuMapper.findMenuByPersonId(pid);
        // 调用递归，组装数据，拼接成树形结构
        List<Map<String, Object>> treeList = getMenu(menuList, 0);
        return treeList;
    }

    public List<Map<String, Object>> getMenu(List<SslMenu> menuList, Integer parentId) {
        // 定义返回数据结果集
        List<Map<String, Object>> listTree = new ArrayList<>();
        // 遍历菜单
        for (int i = 0; i < menuList.size(); i++) {
            // 定义map用来存放组装的数据
            Map<String, Object> treeVo = null;
            // 获取单个菜单对象
            SslMenu menu = menuList.get(i);
            if (menu.getParentid().equals(parentId)) { // 如果当前菜单的父id与我们传过来的id一样
                // 实例化map对象
                treeVo = new HashMap<>();
                treeVo.put("id", menu.getId());
                treeVo.put("text", menu.getText());
                treeVo.put("url", menu.getUrl());
                treeVo.put("icon", menu.getIcon());
                treeVo.put("nodes", getMenu(menuList, menu.getId()));
            }
            // 如果map有数据
            if (treeVo != null) {
                // 将没有子节点的数据删除
                // 1、获取到map的子节点
                List<Map<String, Object>> li = (List<Map<String, Object>>) treeVo.get("nodes");
                // 2、判断子节点是否有数据
                if (li.size() == 0) {// 表示没有子节点
                    // 将nodes节点删除
                    treeVo.remove("nodes");
                }
                // 将map放到list中
                listTree.add(treeVo);
            }
        }
        return listTree;
    }

    // 查询zTree树
    @Override
    public List<Map<String, Object>> getTree() {
        // 获取菜单表中所有的数据
        List<SslMenu> menuList = menuMapper.selectByExample(new SslMenuExample());
        // 调用递归，组装数据，拼接成树形结构
        List<Map<String, Object>> treeList = getTree(menuList, 0);
        return treeList;
    }

    // 组装zTree树形结构
    public List<Map<String, Object>> getTree(List<SslMenu> menuList, Integer parentId) {
        // 定义返回数据结果集
        List<Map<String, Object>> listTree = new ArrayList<>();
        // 遍历菜单
        for (int i = 0; i < menuList.size(); i++) {
            // 定义map用来存放组装的数据
            Map<String, Object> treeVo = null;
            // 获取单个菜单对象
            SslMenu menu = menuList.get(i);
            if (menu.getParentid().equals(parentId)) { // 如果当前菜单的父id与我们传过来的id一样
                // 实例化map对象
                treeVo = new HashMap<>();
                treeVo.put("id", menu.getId());
                treeVo.put("name", menu.getText());
                // treeVo.put("checked", true);
                // treeVo.put("url", menu.getUrl());
                // treeVo.put("icon", menu.getIcon());
                treeVo.put("children", getTree(menuList, menu.getId()));
            }
            // 如果map有数据
            if (treeVo != null) {
                // 将没有子节点的数据删除
                // 1、获取到map的子节点
                List<Map<String, Object>> li = (List<Map<String, Object>>) treeVo.get("children");
                // 2、判断子节点是否有数据
                if (li.size() == 0) {// 表示没有子节点
                    // 将nodes节点删除
                    treeVo.remove("children");
                }
                // 将map放到list中
                listTree.add(treeVo);
            }
        }
        return listTree;
    }

    @Override
    public void saveMenu(SslMenu menu) {
        menuMapper.insertSelective(menu);
    }

    @Override
    public SslMenu findMenuById(Integer id) {

        return menuMapper.selectByPrimaryKey(id);
    }

    @Override
    public void updateMenu(SslMenu menu) {
        menuMapper.updateByPrimaryKeySelective(menu);
    }

    @Override
    public void deleteMenu(Integer id) {
        menuMapper.deleteByPrimaryKey(id);
    }

    // 构建zTree
    @Override
    public List<Map<String, Object>> getCheckedTree(Integer roleId) {
        // 2、查询权限树所有的数据
        List<SslMenu> menus = menuMapper.selectByExample(new SslMenuExample());
        // 3、根据当前角色查询，当前角色所拥有的权限
        List<Integer> menuIds = menuMapper.selectMenuIdByRoleId(roleId);
        // 4、调用递归构建权限树，并且将当前角色所拥有的权限，在权限树上被选中
        List<Map<String, Object>> ztree = getCheckedTree(menus,0,menuIds);
        return ztree;
    }

    @Override
    public List<String> getMenuById(Integer pid) {
        return menuMapper.getMenuById(pid);
    }

    //组装zTree，并且选中
    private List<Map<String, Object>> getCheckedTree(List<SslMenu> menuList, int parentId, List<Integer> menuIds) {
        // 定义返回数据结果集
        List<Map<String, Object>> listTree = new ArrayList<>();
        // 遍历菜单
        for (int i = 0; i < menuList.size(); i++) {
            // 定义map用来存放组装的数据
            Map<String, Object> treeVo = null;
            // 获取单个菜单对象
            SslMenu menu = menuList.get(i);
            if (menu.getParentid().equals(parentId)) { // 如果当前菜单的父id与我们传过来的id一样
                // 实例化map对象
                treeVo = new HashMap<>();
                treeVo.put("id", menu.getId());
                treeVo.put("name", menu.getText());
                //判断树的id和角色所拥有的权限id是否相等
                if(menuIds !=null && menuIds.size() > 0 && menuIds.contains(menu.getId())){//contains 包含
                    treeVo.put("checked", true);
                }
                // treeVo.put("url", menu.getUrl());
                // treeVo.put("icon", menu.getIcon());
                treeVo.put("children", getCheckedTree(menuList, menu.getId(),menuIds));
            }
            // 如果map有数据
            if (treeVo != null) {
                // 将没有子节点的数据删除
                // 1、获取到map的子节点
                List<Map<String, Object>> li = (List<Map<String, Object>>) treeVo.get("children");
                // 2、判断子节点是否有数据
                if (li.size() == 0) {// 表示没有子节点
                    // 将nodes节点删除
                    treeVo.remove("children");
                }
                // 将map放到list中
                listTree.add(treeVo);
            }
        }
        return listTree;
    }

}
